// pages/cart/cart.js
const {
  getCartList,
  updateCartQuantity,
  deleteCartItem,
  toggleCartItemSelection,
  toggleAllCartItems,
  increaseCartQuantity,
  decreaseCartQuantity,
  chooseCartItem,
  cancelCartItem,
} = require("../../api/cart.js");
const userStore = require("../../store/userStore.js");
const {
  navigateFromCartToProductDetail,
  hasNavigationHistory,
  addNavigationRecord,
} = require("../../utils/navigation-history.js");

Page({
  data: {
    loading: true,
    refreshing: false,
    cartList: [],
    summary: {
      selectedCount: 0,
      totalAmount: 0,
      totalSaveAmount: 0,
      totalCount: 0,
      hasSelected: false,
    },
    selectAll: false,
    // 登录状态
    isLoggedIn: false,
    // 返回按钮相关
    showBackButton: false,
    backButtonIcon: "‹",
  },

  onLoad() {
    console.log("购物车页面加载");
    this.checkLoginStatus();
  },

  onShow() {
    console.log("购物车页面显示");
    // 每次显示时检查登录状态，但不重新加载数据以避免闪屏
    const isLoggedIn = userStore.isLoggedIn();
    this.setData({ isLoggedIn });

    // 检查返回按钮状态
    this.checkBackButtonStatus();

    // 更新TabBar状态（只更新购物车数量）
    const app = getApp();
    app.updateCustomTabBar();

    // 检查是否有添加购物车动作
    if (app.globalData.addCarAction) {
      console.log("检测到添加购物车动作，显示加载动画并刷新数据");
      // 显示500ms加载动画
      this.setData({ loading: true });

      // 500ms后加载购物车数据
      setTimeout(() => {
        this.loadCartList();
      }, 500);

      // 重置添加购物车动作标记
      app.globalData.addCarAction = false;
    } else if (isLoggedIn && this.data.cartList.length === 0) {
      // 只有在登录状态发生变化时才重新加载数据
      this.loadCartList();
    }
  },

  onHide() {
    console.log("购物车页面隐藏");
    // 页面隐藏时不做任何操作，保持当前状态
  },

  // 检查返回按钮状态
  checkBackButtonStatus() {
    const app = getApp();
    const jumpHistory = app.globalData.jumpHistory || [];
    const showBackButton = jumpHistory.length > 0;

    console.log(
      "购物车页面：检查返回按钮状态，jumpHistory:",
      jumpHistory,
      "showBackButton:",
      showBackButton
    );

    this.setData({
      showBackButton: showBackButton,
    });
  },

  // 返回按钮点击事件
  goBack() {
    console.log("购物车页面：点击返回按钮");

    const app = getApp();
    const jumpHistory = app.globalData.jumpHistory || [];

    if (jumpHistory.length > 0) {
      const lastJump = jumpHistory[jumpHistory.length - 1];

      // 从历史记录中移除当前项
      jumpHistory.pop();
      app.globalData.jumpHistory = jumpHistory;

      // 跳转到上一个页面
      if (lastJump.fromPageType === "product-detail") {
        wx.navigateTo({
          url: `/pages/product-detail/product-detail?productId=${lastJump.productId}`,
        });
      } else if (lastJump.fromPageType === "cart") {
        wx.switchTab({
          url: "/pages/cart/cart",
        });
      }

      console.log("返回到:", lastJump);
      console.log("剩余历史记录:", jumpHistory);

      // 更新返回按钮状态
      this.setData({
        showBackButton: jumpHistory.length > 0,
      });
    }
  },

  /**
   * 下拉刷新
   */
  onPullDownRefresh() {
    console.log("购物车下拉刷新");

    // 检查登录状态
    const isLoggedIn = userStore.isLoggedIn();
    this.setData({ isLoggedIn });

    if (isLoggedIn) {
      // 已登录，平缓刷新购物车数据
      this.smoothRefreshCartList().finally(() => {
        // 停止下拉刷新动画
        wx.stopPullDownRefresh();
      });
    } else {
      // 未登录，直接停止刷新
      wx.stopPullDownRefresh();
    }
  },

  /**
   * 平缓刷新购物车列表（避免闪屏）
   */
  async smoothRefreshCartList() {
    // 检查登录状态
    if (!this.data.isLoggedIn) {
      console.log("用户未登录，不加载购物车数据");
      return Promise.resolve();
    }

    try {
      // 显示刷新指示器
      this.setData({ refreshing: true });

      const res = await getCartList();
      console.log("购物车API响应:", res);

      if (res.code === 0) {
        const { items, summary } = res.data;
        console.log("购物车商品数据:", items);
        console.log("购物车汇总数据:", summary);

        // 处理购物车数据
        const processedItems = (items || []).map((item) => {
          // 解析specValues JSON字符串
          let parsedSpecValues = [];

          console.log("处理商品规格数据:", item.spuName, item.specValues);

          if (item.specValues && typeof item.specValues === "string") {
            try {
              const parsed = JSON.parse(item.specValues);
              console.log("解析后的规格数据:", parsed);
              if (
                typeof parsed === "object" &&
                parsed !== null &&
                !Array.isArray(parsed)
              ) {
                // 将JSON对象转换为键值对数组
                parsedSpecValues = Object.entries(parsed).map(
                  ([key, value]) => `${key}：${value}`
                );
                console.log("转换后的规格数组:", parsedSpecValues);
              }
            } catch (error) {
              console.error("解析specValues失败:", error);
              parsedSpecValues = [];
            }
          } else if (item.specValues && Array.isArray(item.specValues)) {
            // 如果已经是数组格式，直接使用
            parsedSpecValues = item.specValues;
            console.log("规格数据已经是数组格式:", parsedSpecValues);
          }

          // 生成规格文本
          const specText =
            parsedSpecValues.length > 0 ? parsedSpecValues.join(" | ") : "";

          return {
            cartId: item.cartId,
            spuId: item.spuId,
            skuId: item.skuId,
            spuName: item.spuName,
            mainImage: item.mainImage,
            price: item.price,
            originalPrice: item.originalPrice,
            quantity: item.quantity,
            selected: item.selected,
            available: item.available,
            specValues: parsedSpecValues,
            specText: specText, // 添加格式化的规格文本
            stock: item.stock,
            warnStock: item.warnStock,
            limitQuantity: item.limitQuantity,
            unavailableReason: item.unavailableReason,
            // 用于跳转到商品详情页
            productId: item.spuId,
          };
        });

        // 使用渐变动画更新数据
        this.setData({
          cartList: processedItems,
          summary: summary || {
            selectedCount: 0,
            totalAmount: 0,
            totalSaveAmount: 0,
            totalCount: 0,
            hasSelected: false,
          },
          selectAll:
            processedItems.length > 0 &&
            processedItems.every((item) => item.selected),
        });

        console.log("购物车页面数据更新完成");
      } else {
        // 处理业务异常
        wx.showToast({
          title: res.message || "加载失败",
          icon: "none",
        });
      }
    } catch (error) {
      console.error("加载购物车失败:", error);

      // 显示错误信息
      wx.showToast({
        title: error.message || "加载失败",
        icon: "none",
      });
    } finally {
      // 隐藏刷新指示器
      setTimeout(() => {
        this.setData({ refreshing: false });
      }, 300);
    }
  },

  /**
   * 检查登录状态
   */
  checkLoginStatus() {
    const isLoggedIn = userStore.isLoggedIn();
    console.log("购物车页面登录状态:", isLoggedIn);
    this.setData({ isLoggedIn });

    if (isLoggedIn) {
      // 已登录，加载购物车数据
      this.loadCartList();
    } else {
      // 未登录，显示登录提示
      this.setData({ loading: false });
    }
  },

  /**
   * 加载购物车列表
   */
  async loadCartList() {
    // 检查登录状态
    if (!this.data.isLoggedIn) {
      console.log("用户未登录，不加载购物车数据");
      return Promise.resolve();
    }

    try {
      this.setData({ loading: true });

      const res = await getCartList();
      console.log("购物车API响应:", res);

      if (res.code === 0) {
        const { items, summary } = res.data;
        console.log("购物车商品数据:", items);
        console.log("购物车汇总数据:", summary);

        // 测试specValues解析
        if (items && items.length > 0) {
          const firstItem = items[0];
          console.log("第一个商品的specValues:", firstItem.specValues);
          if (firstItem.specValues) {
            try {
              const parsed = JSON.parse(firstItem.specValues);
              console.log("解析结果:", parsed);
              const converted = Object.entries(parsed).map(
                ([key, value]) => `${key}：${value}`
              );
              console.log("转换结果:", converted);
            } catch (error) {
              console.error("解析失败:", error);
            }
          }
        }

        // 处理购物车数据
        const processedItems = (items || []).map((item) => {
          // 解析specValues JSON字符串
          let parsedSpecValues = [];

          console.log("处理商品规格数据:", item.spuName, item.specValues);

          if (item.specValues && typeof item.specValues === "string") {
            try {
              const parsed = JSON.parse(item.specValues);
              console.log("解析后的规格数据:", parsed);
              if (
                typeof parsed === "object" &&
                parsed !== null &&
                !Array.isArray(parsed)
              ) {
                // 将JSON对象转换为键值对数组
                parsedSpecValues = Object.entries(parsed).map(
                  ([key, value]) => `${key}：${value}`
                );
                console.log("转换后的规格数组:", parsedSpecValues);
              }
            } catch (error) {
              console.error("解析specValues失败:", error);
              parsedSpecValues = [];
            }
          } else if (item.specValues && Array.isArray(item.specValues)) {
            // 如果已经是数组格式，直接使用
            parsedSpecValues = item.specValues;
            console.log("规格数据已经是数组格式:", parsedSpecValues);
          }

          // 生成规格文本
          const specText =
            parsedSpecValues.length > 0 ? parsedSpecValues.join(" | ") : "";

          return {
            cartId: item.cartId,
            spuId: item.spuId,
            skuId: item.skuId,
            spuName: item.spuName,
            mainImage: item.mainImage,
            price: item.price,
            originalPrice: item.originalPrice,
            quantity: item.quantity,
            selected: item.selected,
            available: item.available,
            specValues: parsedSpecValues,
            specText: specText, // 添加格式化的规格文本
            stock: item.stock,
            warnStock: item.warnStock,
            limitQuantity: item.limitQuantity,
            unavailableReason: item.unavailableReason,
            // 用于跳转到商品详情页
            productId: item.spuId,
          };
        });

        this.setData({
          cartList: processedItems,
          summary: summary || {
            selectedCount: 0,
            totalAmount: 0,
            totalSaveAmount: 0,
            totalCount: 0,
            hasSelected: false,
          },
          selectAll:
            processedItems.length > 0 &&
            processedItems.every((item) => item.selected),
        });

        console.log("购物车页面数据设置完成");
      } else {
        // 处理业务异常
        wx.showToast({
          title: res.message || "加载失败",
          icon: "none",
        });
      }
    } catch (error) {
      console.error("加载购物车失败:", error);

      // 显示错误信息
      wx.showToast({
        title: error.message || "加载失败",
        icon: "none",
      });
    } finally {
      // 延迟关闭loading状态，避免闪屏
      setTimeout(() => {
        this.setData({ loading: false });
      }, 100);
    }
  },

  /**
   * 全选/取消全选
   */
  async toggleSelectAll() {
    // 检查登录状态
    if (!this.data.isLoggedIn) {
      wx.showToast({
        title: "请先授权",
        icon: "none",
      });
      return;
    }

    try {
      // 调用全选接口
      const res = await toggleAllCartItems();

      if (res.code === 0) {
        // 根据当前全选状态切换
        const newSelectAll = !this.data.selectAll;

        this.setData({
          selectAll: newSelectAll,
        });

        // 更新所有商品的选中状态
        const cartList = this.data.cartList.map((item) => ({
          ...item,
          selected: newSelectAll,
        }));

        this.setData({ cartList });
        this.calculateSummary();

        // 显示操作结果提示
        wx.showToast({
          title: newSelectAll ? "已全选" : "已取消全选",
          icon: "success",
          duration: 1000,
        });
      } else {
        wx.showToast({
          title: res.message || "操作失败",
          icon: "none",
        });
      }
    } catch (error) {
      console.error("全选操作失败:", error);
      wx.showToast({
        title: "网络错误，请重试",
        icon: "none",
      });
    }
  },

  /**
   * 切换商品选择状态
   */
  async toggleItemSelection(e) {
    // 检查登录状态
    if (!this.data.isLoggedIn) {
      wx.showToast({
        title: "请先授权",
        icon: "none",
      });
      return;
    }

    const cartId = e.currentTarget.dataset.cartId;
    const item = this.data.cartList.find((item) => item.cartId === cartId);

    if (!item) return;

    try {
      const res = await toggleCartItemSelection({
        cartId: cartId,
        selected: !item.selected,
      });

      if (res.code === 0) {
        // 更新本地数据
        const cartList = this.data.cartList.map((item) => {
          if (item.cartId === cartId) {
            return { ...item, selected: !item.selected };
          }
          return item;
        });

        this.setData({ cartList });
        // 重新加载购物车数据以更新统计信息
        this.loadCartList();
      } else {
        wx.showToast({
          title: res.message || "操作失败",
          icon: "none",
        });
      }
    } catch (error) {
      console.error("选择商品失败:", error);

      wx.showToast({
        title: "操作失败",
        icon: "none",
      });
    }
  },

  /**
   * 增加商品数量
   */
  async increaseQuantity(e) {
    const { cartId, quantity, limit } = e.currentTarget.dataset;
    const currentQuantity = parseInt(quantity);

    if (currentQuantity >= limit) {
      wx.showToast({
        title: `最多只能购买${limit}件`,
        icon: "none",
      });
      return;
    }

    try {
      // 调用增加数量的API
      const res = await increaseCartQuantity({ cartId });

      if (res.code === 0) {
        // API调用成功，只更新对应商品的数量，避免重新加载整个列表
        this.updateItemQuantityLocally(cartId, currentQuantity + 1);

        // 自动选中商品
        await this.autoSelectItem(cartId);
      } else {
        // 业务错误，显示后端返回的错误信息
        wx.showToast({
          title: res.message || "操作失败",
          icon: "none",
        });
      }
    } catch (error) {
      console.error("增加数量失败:", error);
      // 网络异常或其他错误
      wx.showToast({
        title: error.message || "网络异常，请重试",
        icon: "none",
      });
    }
  },

  /**
   * 减少商品数量
   */
  async decreaseQuantity(e) {
    const { cartId, quantity } = e.currentTarget.dataset;
    const currentQuantity = parseInt(quantity);

    if (currentQuantity <= 1) {
      // 数量为1时，减少后删除商品
      this.deleteItem({ currentTarget: { dataset: { cartId } } });
      return;
    }

    try {
      // 调用减少数量的API
      const res = await decreaseCartQuantity({ cartId });

      if (res.code === 0) {
        // API调用成功，只更新对应商品的数量，避免重新加载整个列表
        this.updateItemQuantityLocally(cartId, currentQuantity - 1);

        // 自动选中商品
        await this.autoSelectItem(cartId);
      } else {
        // 业务错误，显示后端返回的错误信息
        wx.showToast({
          title: res.message || "操作失败",
          icon: "none",
        });
      }
    } catch (error) {
      console.error("减少数量失败:", error);
      // 网络异常或其他错误
      wx.showToast({
        title: error.message || "网络异常，请重试",
        icon: "none",
      });
    }
  },

  /**
   * 更新商品数量
   */
  async updateQuantity(e) {
    const cartId = e.currentTarget.dataset.cartId;
    const newQuantity = parseInt(e.detail.value) || 1;

    if (newQuantity < 1) {
      wx.showToast({
        title: "数量不能小于1",
        icon: "none",
      });
      return;
    }

    await this.updateItemQuantity(cartId, newQuantity);
  },

  /**
   * 本地更新商品数量（避免重新加载整个列表）
   * @param {string} cartId - 购物车ID
   * @param {number} newQuantity - 新数量
   */
  updateItemQuantityLocally(cartId, newQuantity) {
    const cartList = this.data.cartList;
    const itemIndex = cartList.findIndex((item) => item.cartId === cartId);

    if (itemIndex !== -1) {
      // 更新商品数量
      cartList[itemIndex].quantity = newQuantity;

      // 更新数据
      this.setData({
        cartList: cartList,
      });

      // 重新计算汇总信息
      this.calculateSummary();
    }
  },

  /**
   * 自动选中商品（加减号操作时调用）
   */
  async autoSelectItem(cartId) {
    try {
      const res = await chooseCartItem({ cartId });
      if (res.code === 0) {
        // 更新本地选中状态
        this.updateItemSelectionLocally(cartId, true);
      }
    } catch (error) {
      console.error("自动选中商品失败:", error);
    }
  },

  /**
   * 手动选中商品
   */
  async selectItem(e) {
    const { cartId } = e.currentTarget.dataset;

    try {
      const res = await chooseCartItem({ cartId });
      if (res.code === 0) {
        // 更新本地选中状态
        this.updateItemSelectionLocally(cartId, true);
        wx.showToast({
          title: "已选中",
          icon: "success",
          duration: 1000,
        });
      } else {
        wx.showToast({
          title: res.message || "操作失败",
          icon: "none",
        });
      }
    } catch (error) {
      console.error("选中商品失败:", error);
      wx.showToast({
        title: "网络错误，请重试",
        icon: "none",
      });
    }
  },

  /**
   * 手动取消选中商品
   */
  async unselectItem(e) {
    const { cartId } = e.currentTarget.dataset;

    try {
      const res = await cancelCartItem({ cartId });
      if (res.code === 0) {
        // 更新本地选中状态
        this.updateItemSelectionLocally(cartId, false);
        wx.showToast({
          title: "已取消选中",
          icon: "success",
          duration: 1000,
        });
      } else {
        wx.showToast({
          title: res.message || "操作失败",
          icon: "none",
        });
      }
    } catch (error) {
      console.error("取消选中商品失败:", error);
      wx.showToast({
        title: "网络错误，请重试",
        icon: "none",
      });
    }
  },

  /**
   * 更新商品选中状态（本地）
   */
  updateItemSelectionLocally(cartId, selected) {
    const cartList = this.data.cartList.map((item) => {
      if (item.cartId === cartId) {
        return { ...item, selected };
      }
      return item;
    });

    this.setData({ cartList });
    this.calculateSummary();
  },

  /**
   * 计算购物车汇总信息
   */
  calculateSummary() {
    const cartList = this.data.cartList;
    let selectedCount = 0;
    let totalAmount = 0;
    let totalSaveAmount = 0;
    let totalCount = 0;

    cartList.forEach((item) => {
      if (item.selected) {
        selectedCount += item.quantity;
        totalAmount += item.price * item.quantity;
        if (item.originalPrice && item.originalPrice > item.price) {
          totalSaveAmount += (item.originalPrice - item.price) * item.quantity;
        }
      }
      totalCount += item.quantity;
    });

    // 保留小数点后两位，避免浮点数精度问题
    totalAmount = Math.round(totalAmount * 100) / 100;
    totalSaveAmount = Math.round(totalSaveAmount * 100) / 100;

    this.setData({
      summary: {
        selectedCount,
        totalAmount,
        totalSaveAmount,
        totalCount,
        hasSelected: selectedCount > 0,
      },
      selectAll: selectedCount > 0 && selectedCount === totalCount,
    });

    // 更新全局购物车数量
    const app = getApp();
    app.globalData.cartCount = totalCount;

    // 通知TabBar更新
    app.updateCustomTabBar();
  },

  /**
   * 本地删除商品（避免重新加载整个列表）
   * @param {string} cartId - 购物车ID
   */
  deleteItemLocally(cartId) {
    const cartList = this.data.cartList;
    const itemIndex = cartList.findIndex((item) => item.cartId === cartId);

    if (itemIndex !== -1) {
      // 从列表中删除商品
      cartList.splice(itemIndex, 1);

      // 更新数据
      this.setData({
        cartList: cartList,
      });

      // 重新计算汇总信息
      this.calculateSummary();

      // 如果购物车为空，显示空状态
      if (cartList.length === 0) {
        this.setData({
          cartList: [],
          summary: {
            selectedCount: 0,
            totalAmount: 0,
            totalSaveAmount: 0,
            totalCount: 0,
            hasSelected: false,
          },
          selectAll: false,
        });
      }
    }
  },

  /**
   * 更新商品数量的通用方法
   */
  async updateItemQuantity(cartId, quantity) {
    // 检查登录状态
    if (!this.data.isLoggedIn) {
      wx.showToast({
        title: "请先授权",
        icon: "none",
      });
      return;
    }

    try {
      const res = await updateCartQuantity({
        cartId: cartId,
        quantity: quantity,
      });

      if (res.code === 0) {
        // 更新本地数据
        const cartList = this.data.cartList.map((item) => {
          if (item.cartId === cartId) {
            return { ...item, quantity: quantity };
          }
          return item;
        });

        this.setData({ cartList });
        // 重新加载购物车数据以更新统计信息
        this.loadCartList();
      } else {
        wx.showToast({
          title: res.message || "更新失败",
          icon: "none",
        });
      }
    } catch (error) {
      console.error("更新数量失败:", error);

      wx.showToast({
        title: "更新失败",
        icon: "none",
      });
    }
  },

  /**
   * 删除商品
   */
  async deleteItem(e) {
    // 检查登录状态
    if (!this.data.isLoggedIn) {
      wx.showToast({
        title: "请先授权",
        icon: "none",
      });
      return;
    }

    const cartId = e.currentTarget.dataset.cartId;

    wx.showModal({
      title: "确认删除",
      content: "确定要删除这个商品吗？",
      success: async (res) => {
        if (res.confirm) {
          try {
            const result = await deleteCartItem({ cartId });

            if (result.code === 0) {
              wx.showToast({
                title: "删除成功",
                icon: "success",
              });
              // 本地删除商品，避免重新加载整个列表
              this.deleteItemLocally(cartId);
            } else {
              wx.showToast({
                title: result.message || "删除失败",
                icon: "none",
              });
            }
          } catch (error) {
            console.error("删除商品失败:", error);

            wx.showToast({
              title: "删除失败",
              icon: "none",
            });
          }
        }
      },
    });
  },

  /**
   * 去购物
   */
  goShopping() {
    wx.switchTab({
      url: "/pages/index/index",
    });
  },

  /**
   * 去授权
   */
  goToAuth() {
    this.performWxAuth();
  },

  /**
   * 执行微信授权
   */
  async performWxAuth() {
    try {
      wx.showLoading({
        title: "授权中...",
        mask: true,
      });

      // 调用微信授权登录
      const loginResult = await userStore.wxLogin();

      console.log("购物车页面授权结果:", loginResult);

      wx.hideLoading();

      if (loginResult && (loginResult.token || loginResult.accessToken)) {
        console.log("授权成功，更新页面状态");

        // 授权成功，更新页面状态
        this.setData({
          isLoggedIn: true,
        });

        wx.showToast({
          title: "授权成功",
          icon: "success",
        });

        // 授权成功后加载购物车数据
        this.loadCartList();
      } else {
        console.error("授权失败，loginResult:", loginResult);
        throw new Error("授权失败，未获取到token");
      }
    } catch (error) {
      wx.hideLoading();
      console.error("微信授权失败:", error);

      wx.showModal({
        title: "授权失败",
        content: error.message || "授权过程中发生错误，请重试",
        showCancel: false,
      });
    }
  },

  /**
   * 阻止事件冒泡
   */
  stopPropagation(e) {
    // 阻止事件冒泡，防止触发商品点击事件
  },

  /**
   * 显示所有规格
   */
  showAllSpecs(e) {
    const cartId = e.currentTarget.dataset.cartId;
    const item = this.data.cartList.find((item) => item.cartId === cartId);

    if (item && item.specValues) {
      const specText = item.specValues.join("\n");
      wx.showModal({
        title: `商品规格`,
        content: specText,
        showCancel: false,
        confirmText: "知道了",
        confirmColor: "#ff6b6b",
      });
    }
  },

  /**
   * 点击商品图片跳转到详情页
   */
  onProductImageTap(e) {
    const productId = e.currentTarget.dataset.productId;
    const cartId = e.currentTarget.dataset.cartId;
    console.log("点击商品图片，商品ID:", productId, "购物车ID:", cartId);

    if (productId) {
      // 获取购物车商品信息，用于传递规格信息
      const cartItem = this.data.cartList.find(
        (item) => item.cartId === cartId
      );
      if (cartItem) {
        // 传递规格信息到商品详情页
        this.navigateToProductDetailWithSpec(productId, cartItem);
      } else {
        // 使用新的导航历史管理
        navigateFromCartToProductDetail(productId);
      }
    } else {
      wx.showToast({
        title: "商品信息错误",
        icon: "none",
      });
    }
  },

  /**
   * 带规格信息跳转到商品详情页
   */
  navigateToProductDetailWithSpec(productId, cartItem) {
    // 构建规格参数
    const specParams = {
      productId: productId,
      fromCart: true,
      cartId: cartItem.cartId,
      skuId: cartItem.skuId,
      selectedSpecs: cartItem.specValues || [],
      specText: cartItem.specText || "",
    };

    // 将规格信息存储到全局数据
    getApp().globalData.cartToProductSpec = specParams;

    // 添加导航历史记录
    addNavigationRecord("cart", "product-detail", productId);

    // 跳转到商品详情页
    wx.navigateTo({
      url: `/pages/product-detail/product-detail?productId=${productId}&fromCart=true&cartId=${cartItem.cartId}`,
    });
  },

  /**
   * 去结算
   */
  goCheckout() {
    if (!this.data.summary.hasSelected) {
      wx.showToast({
        title: "请选择要结算的商品",
        icon: "none",
      });
      return;
    }

    // 获取选中的商品
    const selectedItems = this.data.cartList.filter((item) => item.selected);

    // 构建商品数据
    const checkoutItems = selectedItems.map((item) => ({
      id: item.cartId, // 使用cartId作为id
      spuId: item.spuId,
      skuId: item.skuId,
      spuName: item.spuName,
      mainImage: item.mainImage,
      specValues: item.specValues,
      specImage:
        item.specImage || item.image || item.skuImage || item.specImg || "", // 添加规格图片
      unitPrice: item.price, // 使用price字段作为unitPrice
      quantity: item.quantity,
    }));

    // 将商品数据存储到全局数据中
    getApp().globalData.checkoutItems = checkoutItems;

    // 跳转到订单确认页面
    wx.navigateTo({
      url: "/pages/order-confirm/order-confirm",
    });
  },
});
